/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.osiris.persistence.controllers.impl;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import org.osiris.persistence.Modificaciondeec;
import org.osiris.persistence.Requisito;
import org.osiris.persistence.Peticioncambio;
import org.osiris.persistence.controllers.ModificacionInterface;
import org.osiris.persistence.controllers.exceptions.NonexistentEntityException;
import org.osiris.persistence.controllers.exceptions.PreexistingEntityException;

/**
 *
 * @author amartinez
 */
public class ModificaciondeecJpaController implements ModificacionInterface {

    public ModificaciondeecJpaController() {
    	emf = CreadorPU.getEntityManagerFactory();
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Modificaciondeec modificaciondeec) throws PreexistingEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Requisito idRequisitoorigen = modificaciondeec.getIdRequisitoorigen();
            if (idRequisitoorigen != null) {
                idRequisitoorigen = em.getReference(idRequisitoorigen.getClass(), idRequisitoorigen.getIdRequisito());
                modificaciondeec.setIdRequisitoorigen(idRequisitoorigen);
            }
            Requisito idRequisitodestino = modificaciondeec.getIdRequisitodestino();
            if (idRequisitodestino != null) {
                idRequisitodestino = em.getReference(idRequisitodestino.getClass(), idRequisitodestino.getIdRequisito());
                modificaciondeec.setIdRequisitodestino(idRequisitodestino);
            }
            Peticioncambio peticioncambioOrigen = modificaciondeec.getPeticioncambioOrigen();
            if (peticioncambioOrigen != null) {
                peticioncambioOrigen = em.getReference(peticioncambioOrigen.getClass(), peticioncambioOrigen.getIdPeticion());
                modificaciondeec.setPeticioncambioOrigen(peticioncambioOrigen);
            }
            em.persist(modificaciondeec);
            if (idRequisitoorigen != null) {
                idRequisitoorigen.getModificaciondeecList().add(modificaciondeec);
                idRequisitoorigen = em.merge(idRequisitoorigen);
            }
            if (idRequisitodestino != null) {
                idRequisitodestino.getModificaciondeecList().add(modificaciondeec);
                idRequisitodestino = em.merge(idRequisitodestino);
            }
            if (peticioncambioOrigen != null) {
                peticioncambioOrigen.getModificaciondeecList().add(modificaciondeec);
                peticioncambioOrigen = em.merge(peticioncambioOrigen);
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findModificaciondeec(modificaciondeec.getIdModificacionDeRequisito()) != null) {
                throw new PreexistingEntityException("Modificaciondeec " + modificaciondeec + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Modificaciondeec modificaciondeec) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Modificaciondeec persistentModificaciondeec = em.find(Modificaciondeec.class, modificaciondeec.getIdModificacionDeRequisito());
            Requisito idRequisitoorigenOld = persistentModificaciondeec.getIdRequisitoorigen();
            Requisito idRequisitoorigenNew = modificaciondeec.getIdRequisitoorigen();
            Requisito idRequisitodestinoOld = persistentModificaciondeec.getIdRequisitodestino();
            Requisito idRequisitodestinoNew = modificaciondeec.getIdRequisitodestino();
            Peticioncambio peticioncambioOrigenOld = persistentModificaciondeec.getPeticioncambioOrigen();
            Peticioncambio peticioncambioOrigenNew = modificaciondeec.getPeticioncambioOrigen();
            if (idRequisitoorigenNew != null) {
                idRequisitoorigenNew = em.getReference(idRequisitoorigenNew.getClass(), idRequisitoorigenNew.getIdRequisito());
                modificaciondeec.setIdRequisitoorigen(idRequisitoorigenNew);
            }
            if (idRequisitodestinoNew != null) {
                idRequisitodestinoNew = em.getReference(idRequisitodestinoNew.getClass(), idRequisitodestinoNew.getIdRequisito());
                modificaciondeec.setIdRequisitodestino(idRequisitodestinoNew);
            }
            if (peticioncambioOrigenNew != null) {
                peticioncambioOrigenNew = em.getReference(peticioncambioOrigenNew.getClass(), peticioncambioOrigenNew.getIdPeticion());
                modificaciondeec.setPeticioncambioOrigen(peticioncambioOrigenNew);
            }
            modificaciondeec = em.merge(modificaciondeec);
            if (idRequisitoorigenOld != null && !idRequisitoorigenOld.equals(idRequisitoorigenNew)) {
                idRequisitoorigenOld.getModificaciondeecList().remove(modificaciondeec);
                idRequisitoorigenOld = em.merge(idRequisitoorigenOld);
            }
            if (idRequisitoorigenNew != null && !idRequisitoorigenNew.equals(idRequisitoorigenOld)) {
                idRequisitoorigenNew.getModificaciondeecList().add(modificaciondeec);
                idRequisitoorigenNew = em.merge(idRequisitoorigenNew);
            }
            if (idRequisitodestinoOld != null && !idRequisitodestinoOld.equals(idRequisitodestinoNew)) {
                idRequisitodestinoOld.getModificaciondeecList().remove(modificaciondeec);
                idRequisitodestinoOld = em.merge(idRequisitodestinoOld);
            }
            if (idRequisitodestinoNew != null && !idRequisitodestinoNew.equals(idRequisitodestinoOld)) {
                idRequisitodestinoNew.getModificaciondeecList().add(modificaciondeec);
                idRequisitodestinoNew = em.merge(idRequisitodestinoNew);
            }
            if (peticioncambioOrigenOld != null && !peticioncambioOrigenOld.equals(peticioncambioOrigenNew)) {
                peticioncambioOrigenOld.getModificaciondeecList().remove(modificaciondeec);
                peticioncambioOrigenOld = em.merge(peticioncambioOrigenOld);
            }
            if (peticioncambioOrigenNew != null && !peticioncambioOrigenNew.equals(peticioncambioOrigenOld)) {
                peticioncambioOrigenNew.getModificaciondeecList().add(modificaciondeec);
                peticioncambioOrigenNew = em.merge(peticioncambioOrigenNew);
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = modificaciondeec.getIdModificacionDeRequisito();
                if (findModificaciondeec(id) == null) {
                    throw new NonexistentEntityException("The modificaciondeec with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Modificaciondeec modificaciondeec;
            try {
                modificaciondeec = em.getReference(Modificaciondeec.class, id);
                modificaciondeec.getIdModificacionDeRequisito();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The modificaciondeec with id " + id + " no longer exists.", enfe);
            }
            Requisito idRequisitoorigen = modificaciondeec.getIdRequisitoorigen();
            if (idRequisitoorigen != null) {
                idRequisitoorigen.getModificaciondeecList().remove(modificaciondeec);
                idRequisitoorigen = em.merge(idRequisitoorigen);
            }
            Requisito idRequisitodestino = modificaciondeec.getIdRequisitodestino();
            if (idRequisitodestino != null) {
                idRequisitodestino.getModificaciondeecList().remove(modificaciondeec);
                idRequisitodestino = em.merge(idRequisitodestino);
            }
            Peticioncambio peticioncambioOrigen = modificaciondeec.getPeticioncambioOrigen();
            if (peticioncambioOrigen != null) {
                peticioncambioOrigen.getModificaciondeecList().remove(modificaciondeec);
                peticioncambioOrigen = em.merge(peticioncambioOrigen);
            }
            em.remove(modificaciondeec);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Modificaciondeec> findModificaciondeecEntities() {
        return findModificaciondeecEntities(true, -1, -1);
    }

    public List<Modificaciondeec> findModificaciondeecEntities(int maxResults, int firstResult) {
        return findModificaciondeecEntities(false, maxResults, firstResult);
    }

    private List<Modificaciondeec> findModificaciondeecEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from Modificaciondeec as o");
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Modificaciondeec findModificaciondeec(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Modificaciondeec.class, id);
        } finally {
            em.close();
        }
    }

    public int getModificaciondeecCount() {
        EntityManager em = getEntityManager();
        try {
            return ((Long) em.createQuery("select count(o) from Modificaciondeec as o").getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
